home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 December / CHIPNET Aralık 1997.iso / linux / redhat / misc / src / install / net.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-11  |  28.7 KB  |  1,144 lines
  1. #include <linux/if.h>
  2. #include <linux/route.h>
  3. #include <sys/ioctl.h>
  4. #include <sys/time.h>
  5. #include <sys/types.h>
  6.  
  7. #include <ctype.h>
  8. #include <errno.h>
  9. #include <netinet/in.h>
  10. #include <netinet/ip.h>
  11. #include <arpa/inet.h>
  12. #include <resolv.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <unistd.h>
  17.  
  18. #include "bootpc.h"
  19. #include "devices.h"
  20. #include "install.h"
  21. #include "log.h"
  22. #include "newt.h"
  23. #include "net.h"
  24. #include "perror.h"
  25. #include "windows.h"
  26.  
  27. struct intfconfig_s {
  28.     newtComponent ipLabel, nmLabel, gwLabel, nsLabel;
  29.     newtComponent ipEntry, nmEntry, gwEntry, nsEntry;
  30.     char * ip, * nm, * gw, * ns;
  31.     char * bootpState;
  32. };
  33.  
  34. struct netconfig_s {
  35.     newtComponent nsLabels[3], hnLabel, dnLabel;
  36.     newtComponent nsEntrys[3], hnEntry, dnEntry;
  37.     char * ns[3], * gw, * hn, * dn;
  38. };
  39.  
  40. static void ipCallback(newtComponent co, void * data);
  41. static void hnCallback(newtComponent co, void * data);
  42.  
  43. /* It's a bit gross, but setupNetworkInterface() will setup your general
  44.    networking information if bootp is used */
  45. static int setupNetworkInterface(struct netInterface * intf,
  46.                  struct netConfig * netc,
  47.                      struct driversLoaded ** dl, int justConfig);
  48. static int doBringUpNetworking(struct netInterface * intf, 
  49.                    struct netConfig * netc,
  50.                    struct driversLoaded ** dl, int justConfig);
  51. static int configureNetDevice(struct netInterface * intf);
  52. /* intf in configureNetwork is optional */
  53. static int configureNetwork(struct netConfig * netc, 
  54.                 struct netInterface * intf);
  55.  
  56. static int doBootp(char * device, struct netInterface * intf,
  57.            struct netConfig * netc) {
  58.     struct netInterface minInterface;
  59.     int rc;
  60.  
  61.     if (testing) return 1;
  62.  
  63.     /* This is a bit of a hack, but it lets us use Jon Peatfield's bootp
  64.         code w/o hacking at it */
  65.  
  66.     logMessage("using bootp for device %s", device);
  67.  
  68.     minInterface.ip = minInterface.netmask = minInterface.network = 0;
  69.     minInterface.broadcast = 0xffffffff; 
  70.     strcpy(minInterface.dev, device);
  71.  
  72.     if (configureNetDevice(&minInterface)) {
  73.     logMessage("failed to setup minimal bootp interface %s", device);
  74.     return 1;
  75.     }
  76.  
  77.     winStatus(40, 3, "BOOTP", "Sending BOOTP request...");
  78.     rc = performBootp(device, "255.255.255.255", "", 10, 0, NULL, 0, 1,
  79.             BP_PUT_ENV);
  80.     newtPopWindow();
  81.  
  82.     if (rc) {
  83.     logMessage("performBootp() failed w/ return %d", rc);
  84.     return 1;
  85.     }
  86.  
  87.     if (!getenv("BOOTP_IPADDR")) {
  88.     errorWindow("bootp query did not return an IP address");
  89.     return 1;
  90.     }
  91.     
  92.     /* These will be generated by bootpc.c even if they're not in the
  93.        bootp reply */
  94.  
  95.     inet_aton(getenv("BOOTP_IPADDR"), (struct in_addr *) &intf->ip);
  96.     inet_aton(getenv("BOOTP_NETMASK"), (struct in_addr *) &intf->netmask);
  97.     inet_aton(getenv("BOOTP_BROADCAST"), (struct in_addr *) 
  98.             &intf->broadcast);
  99.     inet_aton(getenv("BOOTP_NETWORK"), (struct in_addr *) 
  100.             &intf->network);
  101.  
  102.     intf->useBootp = 1;
  103.     intf->isConfigured = 1;
  104.     strcpy(intf->dev, device);
  105.  
  106.     if (getenv("BOOTP_GATEWAYS_1")) {
  107.     strcpy(netc->defaultGateway, getenv("BOOTP_GATEWAYS_1"));
  108.     netc->isConfigured = 1;
  109.     }
  110.  
  111.     if (getenv("BOOTP_DNSSRVS_1")) {
  112.     netc->nameserver[0] = strdup(getenv("BOOTP_DNSSRVS_1"));
  113.     netc->isConfigured = 1;
  114.     if (getenv("BOOTP_DNSSRVS_2"))  {
  115.         netc->nameserver[1] = strdup(getenv("BOOTP_DNSSRVS_2"));
  116.         if (getenv("BOOTP_DNSSRVS_3")) 
  117.         netc->nameserver[2] = strdup(getenv("BOOTP_DNSSRVS_3"));
  118.     }
  119.     }
  120.  
  121.     /* 
  122.     If bootp gave us a hostname and domain, use those. Otherwise,
  123.     we'll try and query the nameserver a bit later on. If that fails
  124.     as well, we'll try and use just the hostname BOOTP gave us.
  125.     */
  126.  
  127.     if (getenv("BOOTP_HOSTNAME") && getenv("BOOTP_DOMAIN")) {
  128.     logMessage("bootp returned hostname and domain name");
  129.     strcpy(netc->hostname, getenv("BOOTP_HOSTNAME"));
  130.     netc->isConfigured = 1;
  131.  
  132.     strcpy(netc->domainname, getenv("BOOTP_DOMAIN"));
  133.  
  134.     if (strcmp(netc->hostname, netc->domainname) &&
  135.         !strstr(netc->hostname, netc->domainname)) {
  136.         strcat(netc->hostname, ".");
  137.         strcat(netc->hostname, netc->domainname);
  138.     }
  139.     } 
  140.  
  141.     return 0;
  142. }
  143.  
  144. /* The interface/gateway needs to be configured before this will work! */
  145. static int guessHostname(struct netInterface * intf, struct netConfig * netc) {
  146.     struct in_addr addr;
  147.     char ips[50];
  148.  
  149.     if (intf->isUp && netc->nameserver[0]) {
  150.     logMessage("using nameserver to find host and domain name");
  151.     writeResolvConf("/etc", netc);
  152.     memcpy(&addr, &intf->ip, sizeof(addr));
  153.     strcpy(ips, inet_ntoa(addr));
  154.     winStatus(40, 3, "Hostname", "Determing host name and domain...");
  155.         if (in2host(ips, BP_PUT_ENV)) {
  156.         newtPopWindow();
  157.         logMessage("reverse name lookup failed");
  158.  
  159.         if (getenv("BOOTP_HOSTNAME")) {
  160.         strcpy(netc->hostname, getenv("BOOTP_HOSTNAME"));
  161.         } 
  162.     } else {
  163.         newtPopWindow();
  164.         logMessage("reverse name lookup worked");
  165.         strcpy(netc->hostname, getenv("BOOTP_HOSTFULL"));
  166.         strcpy(netc->domainname, getenv("BOOTP_HOSTDOMAIN"));
  167.     }
  168.     }
  169.  
  170.     return 0;
  171. }
  172.  
  173. int addDefaultRoute(struct netConfig netc) {
  174.     int s;
  175.     struct rtentry route;
  176.     struct sockaddr_in addr;
  177.  
  178.     if (testing) return 0;
  179.  
  180.     if (!strlen(netc.defaultGateway)) return 0;
  181.  
  182.     s = socket(AF_INET, SOCK_DGRAM, 0);
  183.     if (s < 0) {
  184.     close(s);
  185.     errorWindow("socket: %s");
  186.     return 1;
  187.     }
  188.  
  189.     memset(&route, 0, sizeof(route));
  190.  
  191.     addr.sin_family = AF_INET;
  192.     addr.sin_port = 0;
  193.     inet_aton(netc.defaultGateway, &addr.sin_addr);
  194.     memcpy(&route.rt_gateway, &addr, sizeof(addr));
  195.  
  196.     addr.sin_addr.s_addr = INADDR_ANY;
  197.     memcpy(&route.rt_dst, &addr, sizeof(addr));
  198.     memcpy(&route.rt_genmask, &addr, sizeof(addr));
  199.  
  200.     route.rt_flags = RTF_UP | RTF_GATEWAY;
  201.     route.rt_metric = 0;
  202.  
  203.     if (ioctl(s, SIOCADDRT, &route)) {
  204.     close(s);
  205.     errorWindow("SIOCADDRT: %s");
  206.     return 1;
  207.     }
  208.  
  209.     return 0;
  210. }
  211.  
  212. static int configureNetDevice(struct netInterface * intf) {
  213.     struct ifreq req;
  214.     struct rtentry route;
  215.     int s;
  216.     struct sockaddr_in addr;
  217.     struct in_addr ia;
  218.     char ip[20], nm[20], nw[20], bc[20];
  219.  
  220.     addr.sin_family = AF_INET;
  221.     addr.sin_port = 0;
  222.  
  223.     memcpy(&ia, &intf->ip, sizeof(intf->ip));
  224.     strcpy(ip, inet_ntoa(ia));
  225.  
  226.     memcpy(&ia, &intf->netmask, sizeof(intf->netmask));
  227.     strcpy(nm, inet_ntoa(ia));
  228.  
  229.     memcpy(&ia, &intf->broadcast, sizeof(intf->broadcast));
  230.     strcpy(bc, inet_ntoa(ia));
  231.  
  232.     memcpy(&ia, &intf->network, sizeof(intf->network));
  233.     strcpy(nw, inet_ntoa(ia));
  234.  
  235.     logMessage("configuring %s ip: %s nm: %s nw: %s bc: %s", intf->dev,
  236.         ip, nm, nw, bc);
  237.  
  238.     if (testing) return 0;
  239.     
  240.     strcpy(req.ifr_name, intf->dev);
  241.     addr.sin_family = AF_INET;
  242.     addr.sin_port = 0;
  243.     memcpy(&addr.sin_addr, &intf->ip, sizeof(intf->ip));
  244.  
  245.     s = socket(AF_INET, SOCK_DGRAM, 0);
  246.     if (s < 0) {
  247.     errorWindow("socket: %s");
  248.     return 1;
  249.     }
  250.  
  251.     memcpy(&req.ifr_addr, &addr, sizeof(addr));
  252.     if (ioctl(s, SIOCSIFADDR, &req)) {
  253.     close(s);
  254.     errorWindow("SIOCSIFADDR: %s");
  255.     return 1;
  256.     }
  257.  
  258.     memcpy(&addr.sin_addr, &intf->broadcast, sizeof(intf->broadcast));
  259.     memcpy(&req.ifr_broadaddr, &addr, sizeof(addr));
  260.     if (ioctl(s, SIOCSIFBRDADDR, &req)) {
  261.     close(s);
  262.     errorWindow("SIOCSIFNETMASK: %s");
  263.     return 1;
  264.     }
  265.  
  266.     memcpy(&addr.sin_addr, &intf->netmask, sizeof(intf->netmask));
  267.     memcpy(&req.ifr_netmask, &addr, sizeof(addr));
  268.     if (ioctl(s, SIOCSIFNETMASK, &req)) {
  269.     close(s);
  270.     errorWindow("SIOCSIFNETMASK: %s");
  271.     return 1;
  272.     }
  273.  
  274.     if (intf->isPtp)
  275.     req.ifr_flags = IFF_UP | IFF_RUNNING | IFF_POINTOPOINT | IFF_NOARP;
  276.     else
  277.     req.ifr_flags = IFF_UP | IFF_RUNNING | IFF_BROADCAST;
  278.  
  279.     if (ioctl(s, SIOCSIFFLAGS, &req)) {
  280.     close(s);
  281.     errorWindow("SIOCSIFFLAGS: %s");
  282.     return 1;
  283.     }
  284.  
  285.     memset(&route, 0, sizeof(route));
  286.     route.rt_dev = intf->dev;
  287.     route.rt_flags = RTF_UP;
  288.  
  289.     memcpy(&addr.sin_addr, &intf->network, sizeof(intf->netmask));
  290.     memcpy(&route.rt_dst, &addr, sizeof(addr));
  291.  
  292.     memcpy(&addr.sin_addr, &intf->netmask, sizeof(intf->netmask));
  293.     memcpy(&route.rt_genmask, &addr, sizeof(addr));
  294.  
  295.     if (ioctl(s, SIOCADDRT, &route)) {
  296.     close(s);
  297.     errorWindow("SIOCADDRT: %s");
  298.     return 1;
  299.     }
  300.  
  301.     intf->isUp = 1;
  302.  
  303.     return 0;
  304. }
  305.  
  306. int netDeviceAvailable(char * device) {
  307.     struct ifreq req;
  308.     int s;
  309.     
  310.     s = socket(AF_INET, SOCK_DGRAM, 0);
  311.     if (s < 0) {
  312.     close(s);
  313.     errorWindow("socket: %s");
  314.     return 1;
  315.     }
  316.  
  317.     strcpy(req.ifr_name, device);
  318.  
  319.     if (ioctl(s, SIOCGIFFLAGS, &req)) {
  320.     /* if we can't get the flags, the networking device isn't available */
  321.     close(s);
  322.     return 0;
  323.     }
  324.   
  325.     return 1;
  326. }
  327.  
  328. static void interfaceConfigToggle(newtComponent co, void * arg) {
  329.     struct intfconfig_s * info = arg;
  330.     int sense = NEWT_FLAGS_SET;
  331.  
  332.     if (*info->bootpState == ' ') 
  333.     sense = NEWT_FLAGS_RESET;
  334.  
  335.     newtEntrySetFlags(info->ipEntry, NEWT_ENTRY_DISABLED, sense);
  336.     newtEntrySetFlags(info->nmEntry, NEWT_ENTRY_DISABLED, sense);
  337.     newtEntrySetFlags(info->gwEntry, NEWT_ENTRY_DISABLED, sense);
  338.     newtEntrySetFlags(info->nsEntry, NEWT_ENTRY_DISABLED, sense);
  339.  
  340.     newtRefresh();
  341. }
  342.  
  343. static int setupNetworkInterface(struct netInterface * intf,
  344.                  struct netConfig * netc,
  345.                      struct driversLoaded ** dl, int justConfig) {
  346.     newtComponent okay, cancel, bootp, f, answer;
  347.     int top = 4;
  348.     struct intfconfig_s c;
  349.     struct in_addr addr;
  350.     int32 ptpNetmask;
  351.     int rc;
  352.     int done = 0;
  353.     char useBootp;
  354.     char * device = NULL;
  355.     char * devices[] = { "eth0", "tr0", "plip0", "plip1", "plip2", NULL };
  356.     char ** deviceptr;
  357.     struct driversLoaded * adriver;
  358.  
  359.     /* I should probably ask which device to use if multiple ones are
  360.        available -- oh well :-( */
  361.     for (deviceptr = devices; *deviceptr; deviceptr++) {
  362.     if (netDeviceAvailable(*deviceptr)) {
  363.         device = *deviceptr;
  364.         logMessage("%s is available -- using it for networking", device);
  365.         break;
  366.     }
  367.     }
  368.  
  369.     if (!device) {
  370.     if ((rc = loadDeviceDriver(DRIVER_NET, dl)))
  371.         return rc;
  372.  
  373.     for (adriver = *dl; adriver && adriver->type != DRIVER_NET; 
  374.         adriver = adriver->next);
  375.     if (!adriver) {
  376.         logMessage("ack! loadDriveDriver() worked but didn't load a "
  377.             "DRIVE_NET!!");
  378.         return INST_ERROR;
  379.     }
  380.  
  381.     switch (adriver->minor) {
  382.       case DRIVER_MINOR_ETHERNET:    device = "eth0"; break;
  383.       case DRIVER_MINOR_TR:        device = "tr0"; break;
  384.       case DRIVER_MINOR_PLIP:    device = getPlipDeviceName(); break;
  385.       default:            exit(1); /* ack! */
  386.     }
  387.     }
  388.  
  389.     newtOpenWindow(15, 4, 50, 15, "Configure TCP/IP");
  390.  
  391.     c.ipLabel = newtLabel(1, top + 2, "IP address:");
  392.     c.nmLabel = newtLabel(1, top + 3, "Netmask:");
  393.     c.gwLabel = newtLabel(1, top + 4, "Default gateway (IP):");
  394.     c.nsLabel = newtLabel(1, top + 5, "Primary nameserver:");
  395.    
  396.     if (!intf->ip){
  397.     c.ipEntry = newtEntry(25, top + 2, "", 16, &c.ip, 0);
  398.     } else {
  399.     memcpy(&addr, &intf->ip, sizeof(intf->ip));
  400.     c.ipEntry = newtEntry(25, top + 2, inet_ntoa(addr), 16, &c.ip, 0);
  401.     }
  402.  
  403.     if (!intf->netmask){
  404.     c.nmEntry = newtEntry(25, top + 3, "", 16, &c.nm, 0);
  405.     } else {
  406.     memcpy(&addr, &intf->netmask, sizeof(intf->netmask));
  407.     c.nmEntry = newtEntry(25, top + 3, inet_ntoa(addr), 16, &c.nm, 0);
  408.     }
  409.  
  410.     if (!netc->defaultGateway) 
  411.     c.gwEntry = newtEntry(25, top + 4, "", 16, &c.gw, 0);
  412.     else
  413.     c.gwEntry = newtEntry(25, top + 4, netc->defaultGateway, 16, &c.gw, 0);
  414.  
  415.  
  416.     if (!netc->nameserver[0]) 
  417.     c.nsEntry = newtEntry(25, top + 5, "", 16, &c.ns, 0);
  418.     else
  419.     c.nsEntry = newtEntry(25, top + 5, netc->nameserver[0], 16, &c.gw, 0);
  420.     
  421.     c.bootpState = &useBootp;
  422.    
  423.     f = newtForm(NULL, NULL, 0);
  424.  
  425.     bootp = newtCheckbox(1, top, "Configure device with bootp", 
  426.              (intf->isConfigured && intf->useBootp) ? '*' : ' ', 
  427.              NULL, &useBootp);
  428.  
  429.     newtComponentAddCallback(bootp, interfaceConfigToggle, &c);
  430.  
  431.     newtFormAddComponents(f, bootp, c.ipLabel, c.nmLabel, c.gwLabel, c.nsLabel, 
  432.                  c.ipEntry, c.nmEntry, c.gwEntry, c.nsEntry, NULL);
  433.  
  434.     if (c.bootpState)
  435.     newtFormSetCurrent(f, c.ipEntry);
  436.  
  437.     newtComponentAddCallback(c.ipEntry, ipCallback, &c);
  438.     newtComponentAddCallback(c.nmEntry, ipCallback, &c);
  439.  
  440.     okay = newtButton(8, top + 7, "Ok");
  441.     cancel = newtButton(28, top + 7, "Cancel");
  442.  
  443.     newtFormAddComponents(f, okay, cancel, NULL);
  444.  
  445.     do {
  446.     answer = newtRunForm(f);
  447.  
  448.     if (answer == cancel) {
  449.         newtFormDestroy(f);
  450.         newtPopWindow();
  451.  
  452.         return INST_CANCEL;
  453.     }
  454.  
  455.     if (useBootp != ' ') {
  456.         logMessage("Configuring device %s via bootp", device);
  457.         if (justConfig) {
  458.         done = 1;
  459.         } else if (!doBootp(device, intf, netc)) {
  460.         done = 1;
  461.         }
  462.     } else {
  463.         strcpy(intf->dev, device);
  464.         inet_aton(c.ip, (struct in_addr *) &intf->ip);
  465.         inet_aton(c.nm, (struct in_addr *) &intf->netmask);
  466.         intf->broadcast = (intf->ip & intf->netmask) | (~intf->netmask);
  467.  
  468.         inet_aton("255.255.255.255", (struct in_addr *) &ptpNetmask);
  469.  
  470.         if (ptpNetmask == intf->netmask) {
  471.         logMessage("configuring point to point device");
  472.         inet_aton(c.gw, (struct in_addr *) &intf->network);
  473.         intf->isPtp = 1;
  474.         } else {
  475.         intf->network = intf->ip & intf->netmask;
  476.         intf->isPtp = 0;
  477.         }
  478.  
  479.         intf->isConfigured = 1;
  480.  
  481.         strcpy(netc->defaultGateway, c.gw);
  482.  
  483.         if (netc->nameserver[0]) free(netc->nameserver[0]);
  484.  
  485.         if (strlen(c.ns))
  486.         netc->nameserver[0] = strdup(c.ns);
  487.         else
  488.         netc->nameserver[0] = NULL;
  489.         
  490.         netc->isConfigured = 1;
  491.  
  492.         done = 1;
  493.     }
  494.     } while (!done);
  495.  
  496.     newtFormDestroy(f);
  497.     newtPopWindow();
  498.  
  499.     if (!justConfig) {
  500.     if (configureNetDevice(intf)) return INST_ERROR;
  501.     if (addDefaultRoute(*netc)) return INST_ERROR;
  502.     }
  503.  
  504.     return 0;
  505. } 
  506.  
  507. static void hnCallback(newtComponent co, void * dptr) {
  508.     char * buf;
  509.     struct netconfig_s * data = dptr;
  510.  
  511.     if (strlen(data->hn)) return;
  512.     if (!strlen(data->dn)) return;
  513.  
  514.     buf = alloca(strlen(data->dn) + 5);
  515.     strcpy(buf, ".");
  516.     strcat(buf, data->dn);
  517.     
  518.     newtEntrySet(data->hnEntry, buf, 0);
  519. }
  520.  
  521. static void ipCallback(newtComponent co, void * dptr) {
  522.     struct intfconfig_s * data = dptr;
  523.     struct in_addr ipaddr, nmaddr, addr;
  524.     char * ascii;
  525.     int32 broadcast, network;
  526.  
  527.     if (co == data->ipEntry) {
  528.     if (strlen(data->ip) && !strlen(data->nm)) {
  529.         if (inet_aton(data->ip, &ipaddr)) {
  530.         ipaddr.s_addr = ntohl(ipaddr.s_addr);
  531.         if (((ipaddr.s_addr & 0xFF000000) >> 24) <= 127)
  532.             ascii = "255.0.0.0";
  533.         else if (((ipaddr.s_addr & 0xFF000000) >> 24) <= 191)
  534.             ascii = "255.255.0.0";
  535.         else 
  536.             ascii = "255.255.255.0";
  537.         newtEntrySet(data->nmEntry, ascii, 1);
  538.         }
  539.     }
  540.     } else if (co == data->nmEntry) {
  541.     if (!strlen(data->ip) || !strlen(data->nm)) return;
  542.     if (!inet_aton(data->ip, &ipaddr)) return;
  543.     if (!inet_aton(data->nm, &nmaddr)) return;
  544.  
  545.         network = ipaddr.s_addr & nmaddr.s_addr;
  546.     broadcast = (ipaddr.s_addr & nmaddr.s_addr) | (~nmaddr.s_addr);
  547.  
  548.     addr.s_addr = htonl(ntohl(broadcast) - 1);
  549.     newtEntrySet(data->gwEntry, inet_ntoa(addr), 1);
  550.  
  551.     /* I'm such a lazy bastard */
  552.     if ((ntohl(network) & 0xFFFFFF00) == 0xc7b71800) {
  553.         newtEntrySet(data->nsEntry, "199.183.24.1", 1);
  554.     } else {
  555.         addr.s_addr = htonl(ntohl(network) + 1);
  556.         newtEntrySet(data->nsEntry, inet_ntoa(addr), 1);
  557.     }
  558.     }
  559. }
  560.  
  561. int writeNetConfig(char * prefix, struct netConfig * netc, 
  562.            struct netInterface * gwdev, int verbose) {
  563.     char filename[100];
  564.     FILE * f;
  565.  
  566.     if (testing) return 0;
  567.  
  568.     sprintf(filename, "%s/network", prefix);
  569.  
  570.     f = fopen(filename, "w");
  571.     if (!f) {
  572.     errorWindow("cannot create network config file: %s");
  573.     return INST_ERROR;
  574.     }
  575.  
  576.     fprintf(f, "NETWORKING=yes\n");
  577.  
  578.     logMessage("writing network information to %s", filename);
  579.  
  580.     if (netc->hostname && strlen(netc->hostname)) {
  581.     logMessage("\tnetwork is configured, writing complete information");
  582.     fprintf(f, "HOSTNAME=%s\n", netc->hostname);
  583.     fprintf(f, "DOMAINNAME=%s\n", netc->domainname);
  584.  
  585.     if (gwdev && strlen(netc->defaultGateway)) {
  586.         fprintf(f, "GATEWAY=%s\n", netc->defaultGateway);
  587.         fprintf(f, "GATEWAYDEV=%s\n", gwdev->dev);
  588.     }
  589.  
  590.     if (verbose) {
  591.         if (netc->nameserver[0])
  592.         fprintf(f, "NS1=%s\n", netc->nameserver[0]);
  593.         
  594.         if (netc->nameserver[1])
  595.         fprintf(f, "NS2=%s\n", netc->nameserver[1]);
  596.         
  597.         if (netc->nameserver[2])
  598.         fprintf(f, "NS3=%s\n", netc->nameserver[2]);
  599.     }
  600.     } else {
  601.     logMessage("\tnetwork is not configured");
  602.     fprintf(f, "HOSTNAME=localhost.localdomain\n");
  603.     }
  604.  
  605.     fclose(f);
  606.  
  607.     return 0;
  608. }
  609.  
  610. int writeHosts(char * prefix, struct netConfig * netc, 
  611.            struct netInterface * intf) {
  612.     char filename[100];
  613.     FILE * f;
  614.     struct in_addr * addrptr;
  615.     char * nickname;
  616.     int i;
  617.  
  618.     if (testing) return 1;
  619.  
  620.     sprintf(filename, "%s/hosts", prefix);
  621.  
  622.     /* if /etc/hosts already exists, don't bother creating one */
  623.     if (!access(filename, R_OK)) {
  624.     logMessage("%s already exists -- won't crunch it", filename);
  625.     return 0;
  626.     }
  627.     logMessage("%s doesn not exist -- creating", filename);
  628.  
  629.     f = fopen(filename, "w");
  630.     if (!f) {
  631.     errorWindow("cannot create /etc/hosts: %s");
  632.     return INST_ERROR;
  633.     }
  634.  
  635.     logMessage("writing host information to %s", filename);
  636.  
  637.     fprintf(f, "127.0.0.1\t\tlocalhost localhost.localdomain\n");
  638.     if (netc->hostname && strlen(netc->hostname)) {
  639.     addrptr = (struct in_addr *) &intf->ip;
  640.     i = strlen(netc->hostname) - strlen(netc->domainname);
  641.     if (i > 1 && !strcmp(netc->hostname + i, netc->domainname)
  642.         && netc->hostname[i - 1] == '.') {
  643.         nickname = strdup(netc->hostname);
  644.         nickname[i - 1] = '\0';
  645.         fprintf(f, "%s\t\t%s %s\n", inet_ntoa(*addrptr),
  646.             netc->hostname, nickname);
  647.         free(nickname);
  648.     } else {
  649.         fprintf(f, "%s\t\t%s\n", inet_ntoa(*addrptr),
  650.             netc->hostname);
  651.     }
  652.  
  653.     sethostname(netc->hostname, strlen(netc->hostname));
  654.     }
  655.  
  656.     fclose(f);
  657.  
  658.     res_init();        /* reinit the resolver so DNS changes take affect */
  659.  
  660.     return 0;
  661. }
  662.  
  663. int writeResolvConf(char * prefix, struct netConfig * netc) {
  664.     char filename[100];
  665.     FILE * f;
  666.  
  667.     if (testing) return 1;
  668.  
  669.     if (!netc->domainname && !netc->nameserver[0]) {
  670.     logMessage("networking is not configured - not writing resolv.conf");
  671.     return 0;
  672.     }
  673.  
  674.     sprintf(filename, "%s/resolv.conf", prefix);
  675.  
  676.     f = fopen(filename, "w");
  677.     if (!f) {
  678.     errorWindow("cannot create resolv.conf: %s");
  679.     return INST_ERROR;
  680.     }
  681.  
  682.     logMessage("writing nameservices information to %s", filename);
  683.  
  684.     if (netc->domainname)
  685.     fprintf(f, "search %s\n", netc->domainname);
  686.  
  687.     if (netc->nameserver[0])
  688.     fprintf(f, "nameserver %s\n", netc->nameserver[0]);
  689.     
  690.     if (netc->nameserver[1])
  691.     fprintf(f, "nameserver %s\n", netc->nameserver[1]);
  692.     
  693.     if (netc->nameserver[2])
  694.     fprintf(f, "nameserver %s\n", netc->nameserver[2]);
  695.  
  696.     fclose(f);
  697.  
  698.     res_init();        /* reinit the resolver so DNS changes take affect */
  699.  
  700.     return 0;
  701. }
  702.  
  703. int writeNetInterfaceConfig(char * prefix, struct netInterface * intf) {
  704.     char filename[100];
  705.     FILE * f;
  706.     struct in_addr * addrptr;
  707.  
  708.     if (testing) return 0;
  709.  
  710.     if (!intf->isConfigured) {
  711.     logMessage("network interface is not configured - not creating "
  712.            "ifcfg-*");
  713.     return(0);
  714.     }
  715.  
  716.     sprintf(filename, "%s/ifcfg-%s", prefix, intf->dev);
  717.  
  718.     f = fopen(filename, "w");
  719.     if (!f) {
  720.     errorWindow("cannot create network device config file: %s");
  721.     return INST_ERROR;
  722.     }
  723.  
  724.     logMessage("writing network information to %s", filename);
  725.     
  726.     fprintf(f, "DEVICE=%s\n", intf->dev);
  727.  
  728.     if (intf->useBootp) fprintf(f, "BOOTP=yes\n");
  729.  
  730.     addrptr = (struct in_addr *) &intf->ip;
  731.     fprintf(f, "IPADDR=%s\n", inet_ntoa(*addrptr));
  732.  
  733.     addrptr = (struct in_addr *) &intf->netmask;
  734.     fprintf(f, "NETMASK=%s\n", inet_ntoa(*addrptr));
  735.  
  736.     addrptr = (struct in_addr *) &intf->network;
  737.     fprintf(f, "NETWORK=%s\n", inet_ntoa(*addrptr));
  738.  
  739.     addrptr = (struct in_addr *) &intf->broadcast;
  740.     fprintf(f, "BROADCAST=%s\n", inet_ntoa(*addrptr));
  741.  
  742.     fprintf(f, "ONBOOT=yes\n");
  743.  
  744.     fclose(f);
  745.  
  746.     return 0;
  747. }
  748.  
  749. int readNetInterfaceConfig(char * prefix, char * device, 
  750.                 struct netInterface * intf) {
  751.     FILE * f;
  752.     char * start, * end;
  753.     char buf[250];
  754.     int line = 0;
  755.  
  756.     intf->isConfigured = 0;
  757.  
  758.     if (testing) {
  759.     return 0;
  760.     }
  761.  
  762.     sprintf(buf, "%s/ifcfg-%s", prefix, device);
  763.  
  764.     f = fopen(buf, "r");
  765.     if (!f) {
  766.     if (errno != ENOENT) {
  767.         errorWindow("cannot open file: %s");
  768.         return INST_ERROR;
  769.     } else {
  770.         intf->ip = 0;
  771.         return 0;
  772.     }
  773.     }
  774.  
  775.     while (fgets(buf, sizeof(buf) - 1, f)) {
  776.     line++;
  777.  
  778.     start = buf;
  779.  
  780.     /* skipping leading spaces */
  781.     while (*start && isspace(*start)) start++;
  782.     if (!*start) continue;
  783.  
  784.     /* skip comments */
  785.     if (*start == '#') continue;
  786.  
  787.     /* cut off trailing spaces and \n */
  788.     end = start + strlen(start) - 2;
  789.     while (isspace(*end)) end--;
  790.     end++;
  791.     *end = '\0';    
  792.     end--;
  793.     
  794.     if (!strncmp("IPADDR=", start, 7)) {
  795.         start += 7;
  796.         inet_aton(start, (struct in_addr *) &intf->ip);
  797.     } else if (!strncmp("DEVICE=", start, 7)) {
  798.         start += 7;
  799.         strcpy(intf->dev, start);
  800.     } else if (!strncmp("BOOTP=", start, 6)) {
  801.         intf->useBootp = 1;
  802.     } else if (!strncmp("NETMASK=", start, 8)) {
  803.         start += 8;
  804.         inet_aton(start, (struct in_addr *) &intf->netmask);
  805.     } else if (!strncmp("NETWORK=", start, 8)) {
  806.         start += 8;
  807.         inet_aton(start, (struct in_addr *) &intf->network);
  808.         if (!strcmp(start, "255.255.255.255"))
  809.         intf->isPtp = 1;
  810.     } else if (!strncmp("BROADCAST=", start, 10)) {
  811.         start += 10;
  812.         inet_aton(start, (struct in_addr *) &intf->broadcast);
  813.     }
  814.     }
  815.  
  816.     fclose(f);
  817.  
  818.     intf->isConfigured = 1;
  819.  
  820.     return 0;
  821. }
  822.  
  823. int configureNetwork(struct netConfig * netc, 
  824.              struct netInterface * intf) {
  825.     struct netconfig_s n;
  826.     int top = 3;
  827.     newtComponent f, okay, cancel, answer;
  828.     int i;
  829.  
  830.     newtOpenWindow(15, 4, 50, 15, "Configure Network");
  831.  
  832.     n.dnLabel = newtLabel(1, top    , "Domain name:");
  833.     n.hnLabel = newtLabel(1, top + 1, "Host name:");
  834.     n.nsLabels[1] = newtLabel(1, top + 2, "Secondary nameserver (IP):");
  835.     n.nsLabels[2] = newtLabel(1, top + 3, "Tertiary nameserver (IP):");
  836.  
  837.     n.dnEntry = newtEntry(28, top    , "", 20, &n.dn, NEWT_ENTRY_SCROLL);
  838.     n.hnEntry = newtEntry(28, top + 1, "", 20, &n.hn, NEWT_ENTRY_SCROLL);
  839.     n.nsEntrys[1] = newtEntry(28, top + 2, "", 20, &n.ns[1], NEWT_ENTRY_SCROLL);
  840.     n.nsEntrys[2] = newtEntry(28, top + 3, "", 20, &n.ns[2], NEWT_ENTRY_SCROLL);
  841.  
  842.     if (!strlen(netc->hostname) && !strlen(netc->domainname) && intf->isUp && 
  843.     netc->nameserver[0]) {
  844.     guessHostname(intf, netc);
  845.     } 
  846.  
  847.     if (netc->hostname)
  848.     newtEntrySet(n.hnEntry, netc->hostname, 0);
  849.  
  850.     if (netc->domainname)
  851.     newtEntrySet(n.dnEntry, netc->domainname, 0);
  852.  
  853.     if (netc->nameserver[1])
  854.     newtEntrySet(n.nsEntrys[1], netc->nameserver[1], 0);
  855.     if (netc->nameserver[2])
  856.     newtEntrySet(n.nsEntrys[2], netc->nameserver[2], 0);
  857.  
  858.     newtComponentAddCallback(n.dnEntry, hnCallback, &n);
  859.  
  860.     f = newtForm(NULL, NULL, 0);
  861.     newtFormAddComponents(f, n.dnLabel, n.hnLabel, n.nsLabels[1], 
  862.               n.nsLabels[2], NULL);
  863.     newtFormAddComponents(f, n.dnEntry, n.hnEntry, n.nsEntrys[1], 
  864.               n.nsEntrys[2], NULL);
  865.  
  866.     okay = newtButton(11, 11, "Ok");
  867.     cancel = newtButton(30, 11, "Cancel");
  868.  
  869.     newtFormAddComponents(f, okay, cancel, NULL);
  870.  
  871.     answer = newtRunForm(f);
  872.  
  873.     strcpy(netc->hostname, n.hn);
  874.     strcpy(netc->domainname, n.dn);
  875.  
  876.     for (i = 1; i < 3; i++) {
  877.     if (netc->nameserver[i]) 
  878.         free(netc->nameserver[i]);
  879.     netc->nameserver[i] = *n.ns[i] ? strdup(n.ns[i]) : NULL;
  880.     }
  881.  
  882.     newtFormDestroy(f);
  883.     newtPopWindow();
  884.  
  885.     if (answer == cancel) return INST_CANCEL;
  886.  
  887.     netc->isConfigured = 1;
  888.  
  889.     return 0;
  890. }
  891.  
  892. int readNetConfig(char * prefix, struct netConfig * netc) {
  893.     FILE * f;
  894.     char * start, * end;
  895.     char buf[250];
  896.     int line = 0;
  897.  
  898.     if (testing) {
  899.     return 0;
  900.     }
  901.  
  902.     sprintf(buf, "%s/network", prefix);
  903.  
  904.     f = fopen(buf, "r");
  905.     if (!f) {
  906.     if (errno != ENOENT) {
  907.         errorWindow("cannot open file: %s");
  908.         return INST_ERROR;
  909.     } else {
  910.         netc->hostname[0] = '\0';
  911.         return 0;
  912.     }
  913.     }
  914.  
  915.     memset(netc, 0, sizeof(*netc));
  916.  
  917.     while (fgets(buf, sizeof(buf) - 1, f)) {
  918.     line++;
  919.  
  920.     start = buf;
  921.  
  922.     /* skipping leading spaces */
  923.     while (*start && isspace(*start)) start++;
  924.     if (!*start) continue;
  925.  
  926.     /* skip comments */
  927.     if (*start == '#') continue;
  928.  
  929.     /* cut off trailing spaces and \n */
  930.     end = start + strlen(start) - 2;
  931.     while (isspace(*end)) end--;
  932.     end++;
  933.     *end = '\0';    
  934.     end--;
  935.     
  936.     if (!strncmp("HOSTNAME=", start, 9)) {
  937.         start += 9;
  938.         strcpy(netc->hostname, start);
  939.     } else if (!strncmp("DOMAINNAME=", start, 11)) {
  940.         start += 11;
  941.         strcpy(netc->domainname, start);
  942.     } else if (!strncmp("GATEWAY=", start, 8)) {
  943.         start += 8;
  944.         strcpy(netc->defaultGateway, start);
  945.     } else if (!strncmp("NS1=", start, 4)) {
  946.         start += 4;
  947.         netc->nameserver[0] = strdup(start);
  948.     } else if (!strncmp("NS2=", start, 4)) {
  949.         start += 4;
  950.         netc->nameserver[1] = strdup(start);
  951.     } else if (!strncmp("NS3=", start, 4)) {
  952.         start += 4;
  953.         netc->nameserver[2] = strdup(start);
  954.     }
  955.     }
  956.  
  957.     fclose(f);
  958.  
  959.     netc->isConfigured = 1;
  960.  
  961.     return 0;
  962. }
  963.  
  964.  
  965. int bringUpNetworking(struct netInterface * intf, struct netConfig * netc,
  966.               struct driversLoaded ** dl) {
  967.     return doBringUpNetworking(intf, netc, dl, 0);
  968. }
  969.  
  970. #define BRINGUP_NET     1
  971. #define BRINGUP_CONF    2
  972. #define BRINGUP_ROUTE    3
  973. #define BRINGUP_DONE    4
  974.  
  975. static int doBringUpNetworking(struct netInterface * intf, 
  976.                    struct netConfig * netc,
  977.                    struct driversLoaded ** dl, int justConfig) {
  978.     int where = BRINGUP_NET;
  979.     int rc;
  980.  
  981.     while (where != BRINGUP_DONE) {
  982.     switch (where) {
  983.       case BRINGUP_NET:
  984.         rc = setupNetworkInterface(intf, netc, dl, justConfig);
  985.         if (rc) return rc;
  986.         where = BRINGUP_CONF;
  987.         break;
  988.  
  989.       case BRINGUP_CONF:
  990.         rc = configureNetwork(netc, intf);
  991.         if (rc == INST_CANCEL)
  992.         where = BRINGUP_NET;
  993.         else if (rc)
  994.         return INST_ERROR;
  995.         else
  996.         where = BRINGUP_ROUTE;
  997.         break;
  998.  
  999.       case BRINGUP_ROUTE:
  1000.         if (justConfig)
  1001.         rc = 0;
  1002.         else
  1003.         rc = addDefaultRoute(*netc);
  1004.  
  1005.         if (rc) return rc;
  1006.         where = BRINGUP_DONE;
  1007.         break;
  1008.     }
  1009.     }
  1010.  
  1011.     /* write out the /etc/resolv.conf, as we'll need that to use name services
  1012.        properly */
  1013.     writeResolvConf("/etc", netc);
  1014.  
  1015.     return 0;
  1016. }
  1017.  
  1018. #define CHECKNET_CONFIG        1
  1019. #define CHECKNET_KEEP        2
  1020. #define CHECKNET_NONE        3
  1021. #define CHECKNET_NOBOOTP    4
  1022.  
  1023. static int checkNetConfigPanel(int isConfigured, int useBootp, int * choice) {
  1024.     newtComponent text, okay, cancel;
  1025.     newtComponent f, answer, yes, no, listbox;
  1026.     int which;
  1027.  
  1028.     if (isConfigured) {
  1029.     newtOpenWindow(18, 5, 42, 13, "Network Configuration");
  1030.     text = newtTextbox(1, 1, 40, 2, NEWT_TEXTBOX_WRAP);
  1031.     newtTextboxSetText(text,
  1032.         "LAN networking has already been configured. Do you "
  1033.         "want to:");
  1034.  
  1035.     listbox = newtListbox(8, 4, 0, NEWT_LISTBOX_RETURNEXIT);
  1036.  
  1037.     if (useBootp) {
  1038.         newtListboxAddEntry(listbox, "Use bootp at startup", (void *) 1);
  1039.         newtListboxAddEntry(listbox, "Use the current IP information", 
  1040.                       (void *) 4);
  1041.         newtListboxAddEntry(listbox, "Reconfigure network now",
  1042.                       (void *) 2);
  1043.         newtListboxAddEntry(listbox, "Don't setup networking", (void *) 3);
  1044.     } else {
  1045.         newtListboxAddEntry(listbox, "Keep this setup", (void *) 1);
  1046.         newtListboxAddEntry(listbox, "Reconfigure network now",
  1047.                       (void *) 2);
  1048.         newtListboxAddEntry(listbox, "Don't setup networking", (void *) 3);
  1049.     }
  1050.  
  1051.     okay = newtButton(6, 9, "Ok");
  1052.     cancel = newtButton(23, 9, "Cancel");
  1053.  
  1054.     f = newtForm(NULL, NULL, 0);
  1055.  
  1056.     newtFormAddComponents(f, text, listbox, okay, cancel, NULL);
  1057.  
  1058.     answer = newtRunForm(f);
  1059.     if (answer == cancel) {
  1060.         newtPopWindow();
  1061.         newtFormDestroy(f);
  1062.  
  1063.         return INST_CANCEL;
  1064.     }
  1065.  
  1066.     which = (int) newtListboxGetCurrent(listbox);
  1067.  
  1068.     newtPopWindow();
  1069.     newtFormDestroy(f);
  1070.  
  1071.     if (which == 1)
  1072.         *choice = CHECKNET_KEEP;
  1073.     else if (which == 3)
  1074.         *choice = CHECKNET_NONE;
  1075.     else if (which == 4)
  1076.         *choice = CHECKNET_NOBOOTP;
  1077.     else
  1078.         *choice = CHECKNET_CONFIG;
  1079.     } else {
  1080.     newtOpenWindow(18, 6, 42, 10, "Network Configuration");
  1081.  
  1082.     text = newtTextbox(1, 1, 40, 3, NEWT_TEXTBOX_WRAP);
  1083.     newtTextboxSetText(text,
  1084.         "Do you want to configure LAN (not dialup) networking "
  1085.         "for your installed system?");
  1086.  
  1087.     yes = newtButton(3, 6, " Yes ");
  1088.     no = newtButton(16, 6, "  No  ");
  1089.     cancel = newtButton(29, 6, "Cancel");
  1090.  
  1091.     f = newtForm(NULL, NULL, 0);
  1092.     newtFormAddComponents(f, text, yes, no, cancel, NULL);
  1093.  
  1094.     answer = newtRunForm(f);
  1095.     if (answer == f) 
  1096.         answer = newtFormGetCurrent(f);
  1097.  
  1098.     newtPopWindow();
  1099.     newtFormDestroy(f);
  1100.  
  1101.     if (answer == yes) {
  1102.         *choice = CHECKNET_CONFIG;
  1103.     } else if (answer == cancel) {
  1104.         return INST_CANCEL;
  1105.     } else {
  1106.         *choice = CHECKNET_NONE;
  1107.     }
  1108.     }
  1109.  
  1110.     return 0;
  1111. }
  1112.  
  1113. int checkNetConfig(struct netInterface * intf, struct netConfig * netc,
  1114.            struct driversLoaded ** dl) {
  1115.     int choice, rc;
  1116.  
  1117.     /* this doesn't handle cancel very well as the dl makes it difficult :-( */
  1118.  
  1119.     do {
  1120.     rc = checkNetConfigPanel(netc->isConfigured && intf->isConfigured,
  1121.                  intf->useBootp, &choice);
  1122.     if (rc) return rc;
  1123.  
  1124.     switch (choice) {
  1125.       case CHECKNET_NOBOOTP:
  1126.         intf->useBootp = 0;
  1127.         rc = 0;
  1128.         break;
  1129.  
  1130.       case CHECKNET_CONFIG:
  1131.         rc = doBringUpNetworking(intf, netc, dl, 1);
  1132.         if (rc == INST_ERROR) return rc;
  1133.         break;
  1134.  
  1135.       case CHECKNET_NONE:
  1136.         intf->isConfigured = netc->isConfigured = 0;
  1137.         rc = 0;
  1138.         break;
  1139.     }
  1140.     } while (rc);
  1141.  
  1142.     return 0;
  1143. }
  1144.